/**
 * 此方法是根据wps_sdk.js做的调用方法封装
 * 可参照此定义
 * @param {*} funcs     这是在WPS加载项内部定义的方法，采用JSON格式（先方法名，再参数）
 */
var bUseHttps = false;

function _WpsInvoke(funcs) {
  var info = {};
  info.funcs = funcs;
  // function checkResult(val) {
  //   let result = JSON.parse(val.response)
  //   console.log(result, 11111)
  //   if (result.code === 'SUCCESS') {
  //     bFinished = true
  var func = bUseHttps ? WpsInvoke.InvokeAsHttps : WpsInvoke.InvokeAsHttp;
  func(
    WpsInvoke.ClientType.wps, // 组件类型
    window.wps.wpsAssistName, // 插件名，与wps客户端加载的加载的插件名对应
    "dispatcher", // 插件方法入口，与wps客户端加载的加载的插件代码对应，详细见插件代码
    info, // 传递给插件的数据
    function (result) {
      // 调用回调，status为0为成功，其他是错误
      if (result.status) {
        if (bUseHttps && result.status == 100) {
          WpsInvoke.AuthHttpesCert(
            '请在稍后打开的网页中，点击"高级" => "继续前往"，完成授权。'
          );
          return;
        }
        alert(result.message);
      } else {
        console.log(result.response);
        showresult(result.response);
      }
    }
  );
  //   } else {
  //     if(window.confirm(result.message+'，去下载？')){
  //       openDownloadDialog('http://124.70.215.191:8999/wps/wps_setup.exe','OA助手服务')
  //       return  true
  //     }else{
  //       return false;
  //     }
  //
  //   }
  // }
  //
  // checkLocalService({
  //   url: 'http://localhost:32118/api/wps/check',
  //   sendData: {},
  //   callback: checkResult,
  //   tryCount: 2,
  //   bPop: true,
  //   timeout: 1000,
  //   concurrent: false
  // });
}

/** 检查本地服务开始**/
function openDownloadDialog(url, saveName) {
  if (typeof url == "object" && url instanceof Blob) {
    url = URL.createObjectURL(url); // 创建blob地址
  }
  var aLink = document.createElement("a");
  aLink.href = url;
  aLink.download = saveName || ""; // HTML5新增的属性，指定保存文件名，可以不要后缀，注意，file:///模式下不会生效
  var event;
  if (window.MouseEvent) event = new MouseEvent("click");
  else {
    event = document.createEvent("MouseEvents");
    event.initMouseEvent(
      "click",
      true,
      false,
      window,
      0,
      0,
      0,
      0,
      0,
      false,
      false,
      false,
      false,
      0,
      null
    );
  }
  aLink.dispatchEvent(event);
}

function IEVersion() {
  var userAgent = navigator.userAgent; //取得浏览器的userAgent字符串
  var isIE =
    userAgent.indexOf("compatible") > -1 && userAgent.indexOf("MSIE") > -1; //判断是否IE<11浏览器
  var isEdge = userAgent.indexOf("Edge") > -1 && !isIE; //判断是否IE的Edge浏览器
  var isIE11 =
    userAgent.indexOf("Trident") > -1 && userAgent.indexOf("rv:11.0") > -1;
  if (isIE) {
    var reIE = new RegExp("MSIE (\\d+\\.\\d+);");
    reIE.test(userAgent);
    var fIEVersion = parseFloat(RegExp["$1"]);
    if (fIEVersion == 7) {
      return 7;
    } else if (fIEVersion == 8) {
      return 8;
    } else if (fIEVersion == 9) {
      return 9;
    } else if (fIEVersion == 10) {
      return 10;
    } else {
      return 6; //IE版本<=7
    }
  } else if (isEdge) {
    return 20; //edge
  } else if (isIE11) {
    return 11; //IE11
  } else {
    return 30; //不是ie浏览器
  }
}

function getHttpObj() {
  var httpobj = null;
  if (IEVersion() < 10) {
    try {
      httpobj = new XDomainRequest();
    } catch (e1) {
      httpobj = new createXHR();
    }
  } else {
    httpobj = new createXHR();
  }
  return httpobj;
}

//兼容IE低版本的创建xmlhttprequest对象的方法
function createXHR() {
  if (typeof XMLHttpRequest != "undefined") {
    //兼容高版本浏览器
    return new XMLHttpRequest();
  } else if (typeof ActiveXObject != "undefined") {
    //IE6 采用 ActiveXObject， 兼容IE6
    var versions = [
      //由于MSXML库有3个版本，因此都要考虑
      "MSXML2.XMLHttp.6.0",
      "MSXML2.XMLHttp.3.0",
      "MSXML2.XMLHttp"
    ];

    for (var i = 0; i < versions.length; i++) {
      try {
        return new ActiveXObject(versions[i]);
      } catch (e) {
        //跳过
      }
    }
  } else {
    throw new Error("您的浏览器不支持XHR对象");
  }
}

var fromCharCode = String.fromCharCode;
// encoder stuff
var cb_utob = function (c) {
  if (c.length < 2) {
    var cc = c.charCodeAt(0);
    return cc < 0x80
      ? c
      : cc < 0x800
        ? fromCharCode(0xc0 | (cc >>> 6)) + fromCharCode(0x80 | (cc & 0x3f))
        : fromCharCode(0xe0 | ((cc >>> 12) & 0x0f)) +
        fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) +
        fromCharCode(0x80 | (cc & 0x3f));
  } else {
    var cc =
      0x10000 + (c.charCodeAt(0) - 0xd800) * 0x400 + (c.charCodeAt(1) - 0xdc00);
    return (
      fromCharCode(0xf0 | ((cc >>> 18) & 0x07)) +
      fromCharCode(0x80 | ((cc >>> 12) & 0x3f)) +
      fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) +
      fromCharCode(0x80 | (cc & 0x3f))
    );
  }
};
var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
var utob = function (u) {
  return u.replace(re_utob, cb_utob);
};

var _encode = function (u) {
  var isUint8Array =
    Object.prototype.toString.call(u) === "[object Uint8Array]";
  if (isUint8Array) return u.toString("base64");
  else return btoa(utob(String(u)));
};
if (typeof btoa !== "function") btoa = func_btoa;

function func_btoa(input) {
  var str = String(input);
  var chars =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  for (
    // initialize result and counter
    var block, charCode, idx = 0, map = chars, output = "";
    // if the next str index does not exist:
    //   change the mapping table to "="
    //   check if d has no fractional digits
    str.charAt(idx | 0) || ((map = "="), idx % 1);
    // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8
    output += map.charAt(63 & (block >> (8 - (idx % 1) * 8)))
  ) {
    charCode = str.charCodeAt((idx += 3 / 4));
    if (charCode > 0xff) {
      throw new InvalidCharacterError(
        "'btoa' failed: The string to be encoded contains characters outside of the Latin1 range."
      );
    }
    block = (block << 8) | charCode;
  }
  return output;
}

function startWps(req, t, callback) {
  function startWpsInnder(reqInner, tryCount, bPop) {
    if (tryCount < 1) {
      if (callback)
        callback({
          status: 2,
          message: "请允许浏览器打开WPS Office"
        });
      return;
    }
    var bRetry = true;
    var xmlReq = getHttpObj();
    //WPS客户端提供的接收参数的本地服务，HTTP服务端口为58890，HTTPS服务端口为58891
    //这俩配置，取一即可，不可同时启用
    xmlReq.open(reqInner.type, reqInner.url);
    xmlReq.onload = function (res) {
      if (callback)
        callback({
          status: 0,
          res: res
        });
    };
    xmlReq.ontimeout = xmlReq.onerror = function (res) {
      xmlReq.bTimeout = true;
      if (bPop) {
        //打开wps并传参
        window.location.href = "ksoWPSCloudSvr://start=RelayHttpServer"; //是否启动wps弹框
      }
      setTimeout(function () {
        if (bRetry) {
          bRetry = false;
          startWpsInnder(reqInner, --tryCount, false);
        }
      }, 1000);
    };
    if (IEVersion() < 10) {
      xmlReq.onreadystatechange = function () {
        if (xmlReq.readyState != 4) return;
        if (xmlReq.bTimeout) {
          return;
        }
        if (xmlReq.status === 200) xmlReq.onload();
        else xmlReq.onerror();
      };
    }
    xmlReq.timeout = 3000;
    xmlReq.send(t);
  }

  startWpsInnder(req, 3, true);
  return;
}

function LoadLocalAddons(func) {
  var baseData;
  var req = { url: "http://127.0.0.1:58890/publishlist", type: "GET" };
  startWps(req, baseData, function (res) {
    if (res.status == 0) {
      var curList = JSON.parse(res.res.target.response);
      console.log(curList);
      let existed = false;
      let curEle = null;
      if (curList === null) {
        setAddon(func, "enable");
      } else {
        curList.forEach(function (element) {
          if (element.name === window.wps.wpsAssistName) {
            existed = true;
            curEle = element;
          }
        });
        if (existed) {
          if (curEle.enable === "false") {
            setAddon(func, "enable");
          } else {
            _WpsInvoke(func); // NewDoc方法对应于OA助手dispatcher支持的方法名
          }
        } else {
          setAddon(func, "enable");
        }
      }
    } else {
      console.log(res);
      setAddon(func, "choose");
    }
  });
}

function setAddon(func, cmd) {
  var element = {
    name: window.wps.wpsAssistName,
    addonType: "wps",
    online: "true",
    url: window.wps.wpsAssistUrl
  };
  WpsAddonHandleEx(element, cmd, func);
}

function CheckPlugin(element, callback) {
  var xmlReq = getHttpObj();
  var offline = element.online === "false";
  var url = offline ? element.url : element.url + "ribbon.xml";
  xmlReq.open("POST", "http://localhost:58890/redirect/runParams");
  xmlReq.onload = function (res) {
    if (
      (offline && res.target.response.startsWith("7z")) ||
      (!offline && res.target.response.startsWith("<customUI"))
    ) {
      callback({ result: true });
    } else {
      alert("加载项异常");
      callback({ result: false });
    }
  };
  xmlReq.onerror = function (res) {
    alert("加载项异常");
    callback({ result: false });
  };
  xmlReq.ontimeout = function (res) {
    alert("加载项异常");
    callback({ result: false });
  };
  if (IEVersion() < 10) {
    xmlReq.onreadystatechange = function () {
      if (xmlReq.readyState != 4) return;
      if (xmlReq.bTimeout) {
        return;
      }
      if (xmlReq.status === 200) xmlReq.onload();
      else xmlReq.onerror();
    };
  }
  xmlReq.timeout = 5000;
  var data = {
    method: "get",
    url: url,
    data: ""
  };
  var sendData = FormatSendData(data);
  xmlReq.send(sendData);
}

function WpsAddonHandleEx(element, cmd, func) {
  if (cmd === "choose") {
    if (confirm("点击确定将安装 WPS OA助手")) {
      cmd = "enable";
    } else {
      cmd = "disable";
    }
  }
  CheckPlugin(element, checkCallBack);

  function checkCallBack(val) {
    console.log(val);
    if (val.result === true) {
      var data = FormartData(element, cmd);
      var req = {
        url: "http://localhost:58890/deployaddons/runParams",
        type: "POST"
      };
      startWps(req, data, function (res) {
        console.log(res, func);
        if (res.status == 0) {
          _WpsInvoke(func); // NewDoc方法对应于OA助手dispatcher支持的方法名
        } else {
          alert(res.message);
        }
      });
    }
  }
}

function FormartData(element, cmd) {
  var data = {
    cmd: cmd, //"enable", 启用， "disable", 禁用, "disableall", 禁用所有
    name: element.name,
    url: element.url,
    addonType: element.addonType,
    online: element.online,
    version: element.version
  };
  return FormatSendData(data);
}

function encode(u, urisafe) {
  return !urisafe
    ? _encode(u)
    : _encode(String(u))
      .replace(/[+\/]/g, function (m0) {
        return m0 == "+" ? "-" : "_";
      })
      .replace(/=/g, "");
}

function FormatSendData(data) {
  var strData = JSON.stringify(data);
  if (IEVersion() < 10) eval("strData = '" + JSON.stringify(strData) + "';");
  return encode(strData);
}

var bFinished = true;

function checkLocalService(options) {
  if (!bFinished && !options.concurrent) {
    if (options.callback)
      options.callback({
        status: 1,
        response: JSON.stringify({
          code: 2,
          message: "上一次请求没有完成"
        })
      });
    return;
  }
  bFinished = false;

  // 开始
  function startWpsCheck(tryCount) {
    if (tryCount <= 0) {
      if (bFinished) return;
      bFinished = true;
      if (options.callback)
        options.callback({
          status: 0,
          response: JSON.stringify({
            code: 2,
            message: "未安装OA助手服务"
          })
        });
      return;
    }
    var xmlReq = getHttpObj();
    //WPS客户端提供的接收参数的本地服务，HTTP服务端口为58890，HTTPS服务端口为58891
    //这俩配置，取一即可，不可同时启用
    xmlReq.open("GET", options.url);
    xmlReq.onload = function (res) {
      if (options.callback) {
        options.callback({
          status: 0,
          response: IEVersion() < 10 ? xmlReq.responseText : res.target.response
        });
      }
    };
    xmlReq.ontimeout = xmlReq.onerror = function (res) {
      xmlReq.bTimeout = true;
      if (tryCount == options.tryCount && options.bPop) {
      }
      setTimeout(function () {
        startWpsCheck(tryCount - 1);
      }, 1000);
    };
    if (IEVersion() < 10) {
      xmlReq.onreadystatechange = function () {
        if (xmlReq.readyState != 4) return;
        if (xmlReq.bTimeout) {
          return;
        }
        if (xmlReq.status === 200) xmlReq.onload();
        else xmlReq.onerror();
      };
    }
    xmlReq.timeout = options.timeout;
    xmlReq.send(options.sendData);
  }

  startWpsCheck(options.tryCount);
  return;
}

/***
 * 暂时不用
 * */
export function startCheckWps(callback) {
  checkLocalService({
    url: "http://localhost:32118/api/wps/check",
    sendData: {},
    callback: callback,
    tryCount: 3,
    bPop: true,
    timeout: 5000,
    concurrent: false
  });
}

/** 检查本地服务结束2020-09-21**/

/**
 * 该方法封装了发送给WPS客户端的请求，不需要用户去实现
 * 接收消息：WpsInvoke.RegWebNotify（type，name,callback）
 * WPS客户端返回消息： wps.OAAssist.WebNotify（message）
 * @param {*} type 加载项对应的插件类型
 * @param {*} name 加载项对应的名字
 * @param {func} callback 接收到WPS客户端的消息后的回调函数
 */
// WpsInvoke.RegWebNotify(WpsInvoke.ClientType.wps, "WpsOAAssist", function (messageText) {
//     var span = window.parent.document.getElementById("webnotifyspan")
//     span.innerHTML = messageText
// })

/**
 * 处理WPS加载项的方法返回值
 *
 * @param {*} resultData
 */

function showresult(resultData) {
  let json = eval("(" + resultData + ")");
  switch (json.message) {
    case "GetDocStatus": {
      let docstatus = json.docstatus;
      if (typeof docstatus != "undefined") {
        let str =
          "文档保存状态：" +
          docstatus.saved +
          "\n文档字数：" +
          docstatus.words +
          "\n文档页数：" +
          docstatus.pages;
        alert(str);
      }
    }
  }
}

/**
 * 这是页面中针对代码显示的变量定义，开发者无需关心
 */
var _wps = {};

// 此处往下，都是对于前端页面如何调用WPS加载项方法的样例，开发者请参考

export function newDoc(
  userName,
  documentId,
  flowId,
  taskId,
  instanceId,
  socketClientId,
  newFileName
) {
  LoadLocalAddons([
    {
      NewDoc: {
        uploadPath: GetUploadPath(
          documentId,
          flowId,
          taskId,
          instanceId,
          socketClientId
        ),
        userName: userName,
        newFileName: newFileName,
        notifyUrl: GetNoticeUrl(socketClientId),
        token: window.sessionStorage.getItem("token")
      }
    }
  ]);
}

_wps["newDoc"] = {
  action: newDoc,
  code: _WpsInvoke.toString() + "\n\n" + newDoc.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，打开WPS文字后,新建一个空白doc文档\n\
\n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行插件中的js函数NewDoc,新建一个空白doc\n\
    funcs参数说明:\n\
        NewDoc方法对应于OA助手dispatcher支持的方法名\n\
"
};

function GetDemoPath(fileName) {
  var url = document.location.host;
  return document.location.protocol + "//" + url + "/file/" + fileName;
}

// 获取上传地址
function GetUploadPath(documentId, flowId, taskId, instanceId, socketClientId) {
  var url =
    window.api.wpsUploadUrl +
    "?token=" +
    window.sessionStorage.getItem("token");
  if (documentId) {
    url += "&documentId=" + documentId;
  }
  if (flowId) {
    url += "&flowId=" + flowId;
  }
  if (taskId) {
    url += "&taskId=" + taskId;
  }
  if (instanceId) {
    url += "&instanceId=" + instanceId;
  }
  if (socketClientId) {
    url += "&connectionId=" + socketClientId;
  }
  return url;
}
function GetNoticeUrl(socketClientId) {
  var url =
    window.wps.wpsNotice +
    "?token=" +
    window.sessionStorage.getItem("token") +
    "&state={?}";
  if (socketClientId) {
    url += "&connectionId=" + socketClientId;
  }
  return url;
}

// 获取上传地址
function GetFilePath(documentId) {
  let path = window.wps.secretFilePreview ? window.wps.secretFilePreview : window.api.secretFilePreview
  var filePath = path +
    documentId +
    "?token=" +
    window.sessionStorage.getItem("token");
  return filePath;
}

function GetDemoPngPath() {
  var url = document.location.toString();
  url = decodeURI(url);
  if (url.indexOf("/") != -1) {
    url = url.substring(0, url.lastIndexOf("/"));
  }
  if (url.length !== 0) url = url.concat("/WPS.png");

  if (!String.prototype.startsWith) {
    String.prototype.startsWith = function (searchString, position) {
      position = position || 0;
      return this.indexOf(searchString, position) === position;
    };
  }

  if (url.startsWith("file:///")) url = url.substr("file:///".length);
  return url;
}

/**
 * 打开文档
 * @param userName 显示用户名
 * @param fieldName 文件名称
 * @param documentId 文档id
 * @param flowId 流程id
 * @param taskId 任务id
 * @param instanceId 实例id
 * @param protectType 保护方式（不传默认不开启保护，文档保护类型，-1：不启用保护模式，0：只允许对现有内容进行修订，1：只允许添加批注，2：只允许修改窗体域，3：只读）
 * **/
export function openDoc(
  userName,
  fieldName,
  documentId,
  flowId,
  taskId,
  instanceId,
  protectType,
  socketClientId
) {
  _WpsInvoke([
    {
      OpenDoc: {
        docId: documentId, // 文档ID
        uploadPath: GetUploadPath(
          documentId,
          flowId,
          taskId,
          instanceId,
          socketClientId
        ), // 保存文档上传路径
        fileName: GetFilePath(documentId),
        token: window.sessionStorage.getItem("token"),
        uploadFieldName: fieldName,
        picPath: GetDemoPngPath(),
        copyUrl: "backupPath",
        notifyUrl: GetNoticeUrl(socketClientId),
        openType: { protectType: protectType ? protectType : -1 }, //文档保护类型，-1：不启用保护模式，0：只允许对现有内容进行修订，1：只允许添加批注，2：只允许修改窗体域，3：只读
        userName: userName
      }
    }
  ]); // OpenDoc方法对应于OA助手dispatcher支持的方法名
}

// 在线编辑文档
export function onlineEditDoc() {
  var filePath = prompt(
    "请输入打开文件路径（本地或是url）：",
    GetDemoPath("样章.docx")
  );
  var uploadPath = prompt("请输入文档上传路径:", GetUploadPath());
  var uploadFieldName = prompt(
    "请输入文档上传到业务系统时自定义字段：",
    "自定义字段"
  );
  _WpsInvoke([
    {
      OnlineEditDoc: {
        docId: "123", // 文档ID
        uploadPath: uploadPath, // 保存文档上传路径
        fileName: filePath,
        uploadFieldName: uploadFieldName,
        buttonGroups:
          "btnSaveAsFile,btnImportDoc,btnPageSetup,btnInsertDate,btnSelectBookmark", //屏蔽功能按钮
        userName: "东方不败"
      }
    }
  ]); // onlineEditDoc方法对应于OA助手dispatcher支持的方法名
}

_wps["onlineEditDoc"] = {
  action: onlineEditDoc,
  code: _WpsInvoke.toString() + "\n\n" + onlineEditDoc.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入要打开的文档路径，输入文档上传路径，如果传的不是有效的服务端地址，将无法使用保存上传功能。\n\
    打开WPS文字后,将根据文档路径在线打开对应的文档，保存将自动上传指定服务器地址\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
        onlineEditDoc方法对应于OA助手dispatcher支持的方法名\n\
            docId 文档ID\n\
            uploadPath 保存文档上传路径\n\
            fileName 打开的文档路径\n\
            uploadFieldName 文档上传到业务系统时自定义字段\n\
            buttonGroups 屏蔽的OA助手功能按钮\n\
            userName 传给wps要显示的OA用户名\n\
"
};

export function openRevision() {
  var filePath = prompt(
    "请输入打开文件路径（本地或是url）：",
    GetDemoPath("样章.docx")
  );
  var uploadPath = prompt("请输入文档上传路径:");
  _WpsInvoke([
    {
      OpenDoc: {
        uploadPath: uploadPath, // 保存文档上传路径
        fileName: filePath,
        userName: "王五", //用户名
        revisionCtrl: {
          bOpenRevision: true,
          bShowRevision: true
        }
      }
    }
  ]);
}

_wps["openRevision"] = {
  action: openRevision,
  code: _WpsInvoke.toString() + "\n\n" + openRevision.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入参数后，打开WPS文字后，打开指定文档，并打开修订功能，并显示修订\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
    OpenDoc方法对应于OA助手dispatcher支持的方法名\n\
        docId 文档ID\n\
        userName 用户名，设置当前编辑用户名\n\
        fileName 打开的文档路径\n\
        revisionCtrl 修订功能控制参数\n\
"
};

export function closeRevision() {
  var filePath = prompt(
    "请输入打开文件路径（本地或是url）：",
    GetDemoPath("样章.docx")
  );
  var uploadPath = prompt("请输入文档上传路径:");
  _WpsInvoke([
    {
      OpenDoc: {
        docId: "123", // 文档ID
        uploadPath: uploadPath, // 保存文档上传路径
        fileName: filePath,
        userName: "王五", //用户名
        revisionCtrl: {
          bOpenRevision: false,
          bShowRevision: false
        }
      }
    }
  ]);
}

_wps["closeRevision"] = {
  action: closeRevision,
  code: _WpsInvoke.toString() + "\n\n" + closeRevision.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入参数后，打开WPS文字后，打开指定文档，并关闭修订功能\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
    OpenDoc方法对应于OA助手dispatcher支持的方法名\n\
        docId 文档ID\n\
        userName 用户名，设置当前编辑用户名\n\
        fileName 打开的文档路径\n\
        revisionCtrl 修订功能控制参数\n\
"
};

export function protectOpen() {
  var filePath = prompt(
    "请输入打开文件路径（本地或是url）：",
    GetDemoPath("样章.docx")
  );
  var uploadPath = prompt("请输入文档上传路径:");
  _WpsInvoke([
    {
      OpenDoc: {
        docId: "123", // 文档ID
        uploadPath: uploadPath, // 保存文档上传路径
        fileName: filePath,
        openType: {
          //文档打开方式
          // 文档保护类型，-1：不启用保护模式，0：只允许对现有内容进行修订，
          // 1：只允许添加批注，2：只允许修改窗体域(禁止拷贝功能)，3：只读
          protectType: 3,
          password: "123456"
        }
      }
    }
  ]);
}

_wps["protectOpen"] = {
  action: protectOpen,
  code: _WpsInvoke.toString() + "\n\n" + protectOpen.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入参数后，打开WPS文字后，打开使用保护模式指定文档\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
    OpenDoc方法对应于OA助手dispatcher支持的方法名\n\
        uploadPath 保存文档上传路径\n\
        docId 文档ID\n\
        fileName 打开的文档路径\n\
        openType 文档打开方式控制参数 protectType：1：不启用保护模式，0：只允许对现有内容进行修订，\n\
        \t\t1：只允许添加批注，2：只允许修改窗体域(禁止拷贝功能)，3：只读 password为密码\n\
"
};

export function openWithPassWd() {
  var filePath = prompt("请输入打开文件路径（本地或是url）：");
  var docPassword = prompt("请输入文档打开密码:");
  var uploadPath = prompt("请输入文档上传路径:");
  _WpsInvoke([
    {
      OpenDoc: {
        docId: "123", // 文档ID
        uploadPath: uploadPath, // 保存文档上传路径
        fileName: filePath,
        docPassword: {
          docPassword: docPassword // 文档密码
        }
      }
    }
  ]);
}

_wps["openWithPassWd"] = {
  action: openWithPassWd,
  code: _WpsInvoke.toString() + "\n\n" + openWithPassWd.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入参数后，打开WPS文字后，使用指定密码打开指定加密文档\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
    OpenDoc方法对应于OA助手dispatcher支持的方法名\n\
        uploadPath 保存文档上传路径\n\
        docId 文档ID\n\
        fileName 打开的文档路径\n\
        docPassword 文档密码\n\
"
};

export function insertRedHeader() {
  var filePath = prompt(
    "请输入打开文件路径，如果为空则对活动文档套红：",
    GetDemoPath("样章.docx")
  );
  var templateURL = prompt(
    "请输入红头模板路径（本地或是url）:",
    GetDemoPath("红头文件.docx")
  );
  if (filePath != "" && filePath != null) {
    _WpsInvoke([
      {
        OnlineEditDoc: {
          docId: "123", // 文档ID
          fileName: filePath,
          insertFileUrl: templateURL,
          bkInsertFile: "Content", //红头模板中填充正文的位置书签名
          buttonGroups:
            "btnSaveAsFile,btnImportDoc,btnPageSetup,btnInsertDate,btnSelectBookmark" //屏蔽功能按钮
        }
      }
    ]);
  } else {
    _WpsInvoke([
      {
        InsertRedHead: {
          insertFileUrl: templateURL,
          bkInsertFile: "Content" //红头模板中填充正文的位置书签名
        }
      }
    ]);
  }
}

_wps["insertRedHeader"] = {
  action: insertRedHeader,
  code: _WpsInvoke.toString() + "\n\n" + insertRedHeader.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入参数后，打开WPS文字后，打开指定文档，然后使用指定红头模板对该文档进行套红头\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
    OpenDoc方法对应于OA助手dispatcher支持的方法名\n\
        docId 文档ID\n\
        fileName 打开的文档路径\n\
        insertFileUrl 指定的红头模板\n\
        bkInsertFile 红头模板中正文的位置书签名\n\
    InsertRedHead方法对应于OA助手dispatcher支持的方法名\n\
        insertFileUrl 指定的红头模板\n\
        bkInsertFile 红头模板中正文的位置书签名\n\
"
};

export function fillTemplate() {
  var filePath = prompt(
    "请输入打开文件路径（本地或是url）：",
    GetDemoPath("样章2.docx")
  );
  var templatePath = prompt(
    "请输入需要填充的数据的请求地址:",
    document.location.protocol +
    "//" +
    document.location.host +
    "/getTemplateData"
  );

  _WpsInvoke([
    {
      OpenDoc: {
        docId: "c2de1fcd1d3e4ac0b3cda1392c36c9", // 文档ID
        fileName: filePath,
        templateDataUrl: templatePath
      }
    }
  ]); // OpenDoc方法对应于OA助手dispatcher支持的方法名
}

_wps["fillTemplate"] = {
  action: fillTemplate,
  code: _WpsInvoke.toString() + "\n\n" + fillTemplate.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入要打开的文档路径，输入文档上传路径，打开WPS文字后,将根据文档路径下载并打开对应的文档，\n\
    并自动从模板服务器获取模板数据并套用到文档中\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
        OpenDoc方法对应于OA助手dispatcher支持的方法名\n\
            docId 文档ID，OA助手用以标记文档的信息，以区分其他文档\n\
            fileName 打开的文档路径\n\
            templateDataUrl 模板的服务器路径\n\
"
};

export function convertDoc() {
  var filePath = prompt(
    "请输入打开文件路径（本地或是url）：",
    GetDemoPath("样章.docx")
  );
  var uploadPath = prompt("请输入文档转换后上传路径:", GetUploadPath());

  _WpsInvoke([
    {
      OpenDoc: {
        docId: "123", // 文档ID
        uploadPath: uploadPath, // 保存文档上传路径
        fileName: filePath,
        suffix: ".pdf",
        uploadWithAppendPath: "1" //与suffix配置使用，传入标志位即可
      }
    }
  ]); // OpenDoc方法对应于OA助手dispatcher支持的方法名
}

_wps["convertDoc"] = {
  action: convertDoc,
  code: _WpsInvoke.toString() + "\n\n" + convertDoc.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入要打开的文档路径，输入文档转换后上传路径，如果传的不是有效的服务端地址，将无法使用保存上传功能。\n\
    打开WPS文字后,将根据文档路径下载并打开对应的文档，转换完将自动上传指定服务器地址\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
        OpenDoc方法对应于OA助手dispatcher支持的方法名\n\
            docId 文档ID，OA助手用以标记文档的信息，以区分其他文档\n\
            uploadPath 保存文档上传路径\n\
            fileName 打开的文档路径\n\
            suffix 转换类型\n\
            uploadWithAppendPath 保存时一并转换的目标格式\n\
"
};

function taskPaneBookMark() {
  var filePath = prompt(
    "请输入打开带书签文件路径（本地或是url）：",
    GetDemoPath("样章.docx")
  );
  _WpsInvoke([
    {
      taskPaneBookMark: {
        fileName: filePath,
        userName: "东方不败"
      }
    }
  ]); // taskPaneBookMark方法对应于OA助手dispatcher支持的方法名
}

_wps["taskPaneBookMark"] = {
  action: taskPaneBookMark,
  code: _WpsInvoke.toString() + "\n\n" + taskPaneBookMark.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入要打开的文档路径，文档中的书签将会在OA助手的Taskpane中显示出来。\n\
    点击TaskPane中的书签，会自动跳转到书签所对应的文件中的位置，点击Taskpane按F2键可以看Taskpane中的html源码。\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
    taskPaneBookMark 方法对应于OA助手dispatcher支持的方法名\n\
        fileName 文档的路径\n\
        userName 传给wps要显示的OA用户名\n\
"
};

export function exitWPS() {
  _WpsInvoke([
    {
      ExitWPS: {}
    }
  ]);
}

_wps["exitWPS"] = {
  action: exitWPS,
  code: _WpsInvoke.toString() + "\n\n" + exitWPS.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，关闭已打开的WPS\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议通知WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
    ExitWPS 方法对应于OA助手dispatcher支持的方法名\n\
"
};

function getDocStatus() {
  _WpsInvoke([
    {
      GetDocStatus: {}
    }
  ]);
}

_wps["getDocStatus"] = {
  action: getDocStatus,
  code: _WpsInvoke.toString() + "\n\n" + getDocStatus.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，获取活动文档的状态\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议通知WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
    GetDocStatus 方法对应于OA助手dispatcher支持的方法名\n\
"
};

//----公文写作的相关方法 这些都必须是在有「公文写作」组件的版本中运行 Start--------
/**
 * 判断当前OS是否是Linux系统
 *
 * @returns
 */
function checkOSisLinux() {
  if (detectOS() == "Linux") {
    return true;
  } else {
    alert("此方法仅在WPS Linux特定版本支持");
  }
}

/**
 * 新建一个使用公文写作打开的公文
 *
 */
function newOfficialDocument() {
  if (checkOSisLinux()) {
    _WpsInvoke([
      {
        NewOfficialDocument: {
          isOfficialDocument: true
        }
      }
    ]); // NewOfficialDocument方法对应于OA助手dispatcher支持的方法名
  }
}

_wps["newOfficialDocument"] = {
  action: newOfficialDocument,
  code: _WpsInvoke.toString() + "\n\n" + newOfficialDocument.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，打开WPS公文写作后,新建一个公文\n\
\n\
  方法使用：\n\
    页面点击按钮， 通过wps客户端协议来启动WPS， 调用oaassist插件， 执行插件中的js函数NewOfficialDocument, 新建一个默认模板的公文 n\
    funcs参数说明:\n\
        NewOfficialDocument方法对应于OA助手dispatcher支持的方法名 n\
"
};

/**
 * 打开一个使用公文写作打开的公文
 */
function openOfficialDocument() {
  if (checkOSisLinux()) {
    var filePath = prompt(
      "请输入打开文件路径（本地或是url）：",
      GetDemoPath("公文样章.wps")
    );
    var uploadPath = prompt("请输入文档上传路径:", GetUploadPath());
    var uploadFieldName = prompt(
      "请输入文档上传到业务系统时自定义字段：",
      "自定义字段"
    );
    var backupPath = prompt("请输入文档备份路径:");
    _WpsInvoke([
      {
        OpenDoc: {
          docId: "123", // 文档ID
          uploadPath: uploadPath, // 保存文档上传路径
          fileName: filePath,
          uploadFieldName: uploadFieldName,
          picPath: GetDemoPngPath(),
          copyUrl: backupPath,
          userName: "东方不败"
        }
      }
    ]); // OpenDoc方法对应于OA助手dispatcher支持的方法名
  }
}

_wps["openOfficialDocument"] = {
  action: openOfficialDocument,
  code: _WpsInvoke.toString() + "\n\n" + openOfficialDocument.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入要打开的文档路径，输入文档上传路径，如果传的不是有效的服务端地址，将无法使用保存上传功能。\n\
    打开WPS文字后,将根据文档路径下载并打开对应的文档，保存将自动上传指定服务器地址\n\
\n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
        OpenDoc方法对应于OA助手dispatcher支持的方法名\n\
            docId 文档ID，OA助手用以标记文档的信息，以区分其他文档\n\
            uploadPath 保存文档上传路径\n\
            fileName 打开的文档路径\n\
            uploadFieldName 文档上传到业务系统时自定义字段\n\
            picPath 插入图片的路径\n\
            copyUrl 备份的服务器路径\n\
            userName 传给wps要显示的OA用户名\n\
"
};

/**
 * 在线不落地打开一个使用公文写作打开的公文
 */
function onlineEditOfficialDocument() {
  if (checkOSisLinux()) {
    var filePath = prompt(
      "请输入打开文件路径（本地或是url）：",
      GetDemoPath("公文样章.wps")
    );
    var uploadPath = prompt("请输入文档上传路径:", GetUploadPath());
    var uploadFieldName = prompt(
      "请输入文档上传到业务系统时自定义字段：",
      "自定义字段"
    );
    _WpsInvoke([
      {
        OnlineEditDoc: {
          docId: "123", // 文档ID
          uploadPath: uploadPath, // 保存文档上传路径
          fileName: filePath,
          uploadFieldName: uploadFieldName,
          buttonGroups:
            "btnSaveAsFile,btnImportDoc,btnPageSetup,btnInsertDate,btnSelectBookmark", //屏蔽功能按钮
          userName: "东方不败"
        }
      }
    ]); // onlineEditDoc方法对应于OA助手dispatcher支持的方法名
  }
}

_wps["onlineEditOfficialDocument"] = {
  action: onlineEditOfficialDocument,
  code: _WpsInvoke.toString() + "\n\n" + onlineEditOfficialDocument.toString(),
  detail:
    "\n\
  说明：\n\
    点击按钮，输入要打开的文档路径，输入文档上传路径，如果传的不是有效的服务端地址，将无法使用保存上传功能。\n\
    打开WPS文字后,将根据文档路径在线打开对应的文档，保存将自动上传指定服务器地址\n\
    \n\
  方法使用：\n\
    页面点击按钮，通过wps客户端协议来启动WPS，调用oaassist插件，执行传输数据中的指令\n\
    funcs参数信息说明:\n\
        OnlineEditDoc方法对应于OA助手dispatcher支持的方法名\n\
            docId 文档ID\n\
            uploadPath 保存文档上传路径\n\
            fileName 打开的文档路径\n\
            uploadFieldName 文档上传到业务系统时自定义字段\n\
            buttonGroups 屏蔽的OA助手功能按钮\n\
            userName 传给wps要显示的OA用户名\n\
"
};

/**
 * 这是HTML页面上的按钮赋予事件的实现，开发者无需关心，使用自己习惯的方式做开发即可
 */
window.onload = function () {
  var btns = document.getElementsByClassName("btn");

  for (var i = 0; i < btns.length; i++) {
    btns[i].onclick = function (event) {
      document.getElementById("blockFunc").style.visibility = "visible";
      var btn2 = document.getElementById("demoBtn");
      btn2.innerText = this.innerText;
      document.getElementById("codeDes").innerText = _wps[
        this.id
      ].detail.toString();
      document.getElementById("code").innerText = _wps[this.id].code.toString();
      var onBtnAction = _wps[this.id].action;

      document.getElementById("demoBtn").onclick = function () {
        //IE不支持箭头函数，改为通用写法
        var xhr = new WpsInvoke.CreateXHR();
        xhr.onload = function () {
          onBtnAction();
        };
        xhr.onerror = function () {
          alert("请确认本地服务端(StartupServer.js)是启动状态");
          return;
        };
        xhr.open("get", "http://127.0.0.1:3888/FileList", true);
        xhr.send();
      };

      hljs.highlightBlock(document.getElementById("code"));
    };
  }
};

/**
 * 检查操作系统
 *
 * @returns Win10 | Win7 | WinVista | Win2003 | WinXP | Win2000 | Linux | Unix | Mac
 */
function detectOS() {
  var sUserAgent = navigator.userAgent;
  var isWin = navigator.platform == "Win32" || navigator.platform == "Windows";
  var isMac =
    navigator.platform == "Mac68K" ||
    navigator.platform == "MacPPC" ||
    navigator.platform == "Macintosh" ||
    navigator.platform == "MacIntel";
  if (isMac) return "Mac";
  var isUnix = navigator.platform == "X11" && !isWin && !isMac;
  if (isUnix) return "Unix";
  var isLinux = String(navigator.platform).indexOf("Linux") > -1;
  if (isLinux) return "Linux";
  if (isWin) {
    var isWin2K =
      sUserAgent.indexOf("Windows NT 5.0") > -1 ||
      sUserAgent.indexOf("Windows 2000") > -1;
    if (isWin2K) return "Win2000";
    var isWinXP =
      sUserAgent.indexOf("Windows NT 5.1") > -1 ||
      sUserAgent.indexOf("Windows XP") > -1;
    if (isWinXP) return "WinXP";
    var isWin2003 =
      sUserAgent.indexOf("Windows NT 5.2") > -1 ||
      sUserAgent.indexOf("Windows 2003") > -1;
    if (isWin2003) return "Win2003";
    var isWinVista =
      sUserAgent.indexOf("Windows NT 6.0") > -1 ||
      sUserAgent.indexOf("Windows Vista") > -1;
    if (isWinVista) return "WinVista";
    var isWin7 =
      sUserAgent.indexOf("Windows NT 6.1") > -1 ||
      sUserAgent.indexOf("Windows 7") > -1;
    if (isWin7) return "Win7";
    var isWin10 =
      sUserAgent.indexOf("Windows NT 6.1") > -1 ||
      sUserAgent.indexOf("Windows 10") > -1;
    if (isWin10) return "Win10";
  }
  return "other";
}

// }
